home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / zgeneric.c < prev    next >
C/C++ Source or Header  |  1997-06-18  |  13KB  |  497 lines
  1. /* Copyright (C) 1989, 1992, 1993, 1994, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zgeneric.c */
  20. /* Array/string/dictionary generic operators for PostScript */
  21. #include "memory_.h"
  22. #include "ghost.h"
  23. #include "errors.h"
  24. #include "oper.h"
  25. #include "estack.h"    /* for forall */
  26. #include "idict.h"
  27. #include "iname.h"
  28. #include "ipacked.h"
  29. #include "ivmspace.h"
  30. #include "store.h"
  31.  
  32. /* This file implements copy, get, put, getinterval, putinterval, */
  33. /* length, and forall, which apply generically to */
  34. /* arrays, strings, and dictionaries.  (Copy also has a special */
  35. /* meaning for copying the top N elements of the stack.) */
  36.  
  37. /* See the comment in opdef.h for an invariant which allows */
  38. /* more efficient implementation of forall. */
  39.  
  40. /* Imported operators */
  41. extern int zcopy_dict(P1(os_ptr));
  42.  
  43. /* Forward references */
  44. private int zcopy_invalid(P1(os_ptr));
  45. private int zcopy_integer(P1(os_ptr));
  46. private int zcopy_interval(P1(os_ptr));
  47. private int copy_interval(P4(os_ptr, uint, os_ptr, client_name_t));
  48.  
  49. /* The type dispatch table for `copy'. */
  50. /* We export it so that Level 2 can extend it to handle gstates. */
  51. op_proc_p zcopy_procs[t_next_index];
  52.  
  53. /* Initialize the generic dispatch table. */
  54. private void
  55. zgeneric_init(void)
  56. {    int i;
  57.  
  58.     /*
  59.      * Because other files may have initialized some entries,
  60.      * we only initialize entries that are zero.
  61.      */
  62.     for ( i = 0; i < t_next_index; i++ )
  63.       if ( zcopy_procs[i] == 0 )
  64.         zcopy_procs[i] = zcopy_invalid;
  65.     /*zcopy_procs[t_integer] = zcopy_integer;*/    /* handled specially */
  66.     zcopy_procs[t_array] = zcopy_procs[t_string] = zcopy_interval;
  67.     zcopy_procs[t_dictionary] = zcopy_dict;
  68. }
  69.  
  70. /* <various1> <various2> copy <various> */
  71. /* <obj1> ... <objn> <int> copy <obj1> ... <objn> <obj1> ... <objn> */
  72. /* Note that this implements copy for arrays and strings, */
  73. /* but not for dictionaries (see zcopy_dict in zdict.c). */
  74. private int
  75. zcopy(register os_ptr op)
  76. {    int type = r_type(op);
  77.     if ( type == t_integer )
  78.       return zcopy_integer(op);
  79.     if ( type >= t_next_index )
  80.       return_error(e_typecheck);
  81.     check_op(2);
  82.     return (*zcopy_procs[type])(op);
  83. }
  84. /* <other> copy */
  85. private int
  86. zcopy_invalid(os_ptr op)
  87. {    return_op_typecheck(op);
  88. }
  89. /* <obj1> ... <objn> <int> copy <obj1> ... <objn> <obj1> ... <objn> */
  90. private int
  91. zcopy_integer(register os_ptr op)
  92. {    os_ptr op1 = op - 1;
  93.     int count, i;
  94.     int code;
  95.     if ( (ulong)op->value.intval > op - osbot )
  96.       {    /* There might be enough elements in other blocks. */
  97.         check_int_ltu(*op, ref_stack_count(&o_stack));
  98.         count = op->value.intval;
  99.       }
  100.     else if ( op1 + (count = op->value.intval) <= ostop )
  101.       {    /* Fast case. */
  102.         memcpy((char *)op, (char *)(op - count), count * sizeof(ref));
  103.         push(count - 1);
  104.         return 0;
  105.       }
  106.     /* Do it the slow, general way. */
  107.     code = ref_stack_push(&o_stack, count - 1);
  108.     if ( code < 0 )
  109.       return code;
  110.     for ( i = 0; i < count; i++ )
  111.       *ref_stack_index(&o_stack, i) =
  112.         *ref_stack_index(&o_stack, i + count);
  113.     return 0;
  114. }
  115. /* <array1> <array2> copy <subarray2> */
  116. /* <string1> <string2> copy <substring2> */
  117. private int
  118. zcopy_interval(register os_ptr op)
  119. {    os_ptr op1 = op - 1;
  120.     int code = copy_interval(op, 0, op1, "copy");
  121.     if ( code < 0 ) return code;
  122.     r_set_size(op, r_size(op1));
  123.     *op1 = *op;
  124.     pop(1);
  125.     return 0;
  126. }
  127.  
  128. /* <array|dict|name|packedarray|string> length <int> */
  129. private int
  130. zlength(register os_ptr op)
  131. {    switch ( r_type(op) )
  132.        {
  133.     case t_array:
  134.     case t_string:
  135.     case t_mixedarray:
  136.     case t_shortarray:
  137.         check_read(*op);
  138.         make_int(op, r_size(op));
  139.         return 0;
  140.     case t_dictionary:
  141.         check_dict_read(*op);
  142.         make_int(op, dict_length(op));
  143.         return 0;
  144.     case t_name:
  145.        {    ref str;
  146.         name_string_ref(op, &str);
  147.         make_int(op, r_size(&str));
  148.        }
  149.         return 0;
  150.     default:
  151.         return_op_typecheck(op);
  152.        }
  153. }
  154.  
  155. /* <array|packedarray|string> <index> get <obj> */
  156. /* <dict> <key> get <obj> */
  157. private int
  158. zget(register os_ptr op)
  159. {    os_ptr op1 = op - 1;
  160.     ref *pvalue;
  161.     switch ( r_type(op1) )
  162.        {
  163.     case t_dictionary:
  164.         check_dict_read(*op1);
  165.         if ( dict_find(op1, op, &pvalue) <= 0 )
  166.             return_error(e_undefined);
  167.         op[-1] = *pvalue;
  168.         break;
  169.     case t_string:
  170.         check_read(*op1);
  171.         check_int_ltu(*op, r_size(op1));
  172.         make_int(op1, op1->value.bytes[(uint)op->value.intval]);
  173.         break;
  174.     default:
  175.        {    int code;
  176.         check_type(*op, t_integer);
  177.         check_read(*op1);
  178.         code = array_get(op1, op->value.intval, op1);
  179.         if ( code < 0 )
  180.           {    /* Might be a stackunderflow reported as typecheck. */
  181.             if ( code == e_typecheck )
  182.               return_op_typecheck(op1);
  183.             else
  184.               return code;
  185.           }
  186.        }
  187.        }
  188.     pop(1);
  189.     return 0;
  190. }
  191.  
  192. /* <array> <index> <obj> put - */
  193. /* <dict> <key> <value> put - */
  194. /* <string> <index> <int> put - */
  195. private int
  196. zput(register os_ptr op)
  197. {    os_ptr op1 = op - 1;
  198.     os_ptr op2 = op1 - 1;
  199.     switch ( r_type(op2) )
  200.        {
  201.     case t_dictionary:
  202.         check_dict_write(*op2);
  203.        {    int code = dict_put(op2, op1, op);
  204.         if ( code < 0 ) return code;    /* error */
  205.        }
  206.         break;
  207.     case t_array:
  208.         check_write(*op2);
  209.         check_int_ltu(*op1, r_size(op2));
  210.         store_check_dest(op2, op);
  211.        {    ref *eltp = op2->value.refs + (uint)op1->value.intval;
  212.         ref_assign_old(op2, eltp, op, "put");
  213.        }    break;
  214.     case t_mixedarray:        /* packed arrays are read-only */
  215.     case t_shortarray:
  216.         return_error(e_invalidaccess);
  217.     case t_string:
  218.         check_write(*op2);
  219.         check_int_ltu(*op1, r_size(op2));
  220.         check_int_leu(*op, 0xff);
  221.         op2->value.bytes[(uint)op1->value.intval] = (byte)op->value.intval;
  222.         break;
  223.     default:
  224.         return_op_typecheck(op2);
  225.        }
  226.     pop(3);
  227.     return 0;
  228. }
  229.  
  230. /* <seq:array|packedarray|string> <index> <count> getinterval <subseq> */
  231. private int
  232. zgetinterval(register os_ptr op)
  233. {    os_ptr op1 = op - 1;
  234.     os_ptr op2 = op1 - 1;
  235.     uint index;
  236.     uint count;
  237.     switch ( r_type(op2) )
  238.        {
  239.     default:
  240.         return_op_typecheck(op2);
  241.     case t_array: case t_string:
  242.     case t_mixedarray:
  243.     case t_shortarray: ;
  244.        }
  245.     check_read(*op2);
  246.     check_int_leu(*op1, r_size(op2));
  247.     index = op1->value.intval;
  248.     check_int_leu(*op, r_size(op2) - index);
  249.     count = op->value.intval;
  250.     switch ( r_type(op2) )
  251.        {
  252.     case t_array: op2->value.refs += index; break;
  253.     case t_string: op2->value.bytes += index; break;
  254.     case t_mixedarray:
  255.        {    const ref_packed *packed = op2->value.packed;
  256.         for ( ; index--; ) packed = packed_next(packed);
  257.         op2->value.packed = packed;
  258.        }    break;
  259.     case t_shortarray: op2->value.packed += index; break;
  260.        }
  261.     r_set_size(op2, count);
  262.     pop(2);
  263.     return 0;
  264. }
  265.  
  266. /* <array1> <index> <array2|packedarray2> putinterval - */
  267. /* <string1> <index> <string2> putinterval - */
  268. private int
  269. zputinterval(register os_ptr op)
  270. {    os_ptr opindex = op - 1;
  271.     os_ptr opto = opindex - 1;
  272.     int code;
  273.     switch ( r_type(opto) )
  274.        {
  275.     default:
  276.         return_op_typecheck(opto);
  277.     case t_mixedarray:
  278.     case t_shortarray:
  279.         return_error(e_invalidaccess);
  280.     case t_array:
  281.     case t_string:
  282.         ;
  283.        }
  284.     check_write(*opto);
  285.     check_int_leu(*opindex, r_size(opto));
  286.     code = copy_interval(opto, (uint)(opindex->value.intval), op, "putinterval");
  287.     if ( code >= 0 ) pop(3);
  288.     return code;
  289. }
  290.  
  291. /* <array|packedarray|string> <<element> proc> forall - */
  292. /* <dict> <<key> <value> proc> forall - */
  293. private int
  294.   array_continue(P1(os_ptr)),
  295.   dict_continue(P1(os_ptr)),
  296.   string_continue(P1(os_ptr)),
  297.   packedarray_continue(P1(os_ptr));
  298. private int forall_cleanup(P1(os_ptr));
  299. private int
  300. zforall(register os_ptr op)
  301. {    os_ptr obj = op - 1;
  302.     register es_ptr ep = esp;
  303.     uint index = 0;            /* only used for dictionaries */
  304.     check_estack(6);
  305. #define cproc (ep + 5)
  306.     switch ( r_type(obj) )
  307.        {
  308.     default:
  309.         return_op_typecheck(obj);
  310.     case t_array:
  311.         check_read(*obj);
  312.         make_op_estack(cproc, array_continue);
  313.         break;
  314.     case t_dictionary:
  315.         check_dict_read(*obj);
  316.         make_op_estack(cproc, dict_continue);
  317.         index = dict_first(obj);
  318.         break;
  319.     case t_string:
  320.         check_read(*obj);
  321.         make_op_estack(cproc, string_continue);
  322.         break;
  323.     case t_mixedarray:
  324.     case t_shortarray:
  325.         check_read(*obj);
  326.         make_op_estack(cproc, packedarray_continue);
  327.         break;
  328.        }
  329.     check_proc(*op);
  330.     /* Push a mark, the composite object, the iteration index, */
  331.     /* and the procedure, and invoke the continuation operator. */
  332.     make_mark_estack(ep + 1, es_for, forall_cleanup);
  333.     ep[2] = *obj;
  334.     make_int(ep + 3, index);
  335.     ep[4] = *op;
  336.     esp += 4;
  337.     pop(2);  op -= 2;
  338.     return (*real_opproc(cproc))(op);
  339. #undef cproc
  340. }
  341. /* Continuation operator for arrays */
  342. private int
  343. array_continue(register os_ptr op)
  344. {    es_ptr obj = esp - 2;
  345.     if ( r_size(obj) )        /* continue */
  346.        {    push(1);
  347.         r_dec_size(obj, 1);
  348.         *op = *obj->value.refs;
  349.         obj->value.refs++;
  350.         esp += 2;
  351.         *esp = obj[2];
  352.         return o_push_estack;
  353.        }
  354.     else                /* done */
  355.        {    esp -= 4;        /* pop mark, object, index, proc */
  356.         return o_pop_estack;
  357.        }
  358. }
  359. /* Continuation operator for dictionaries */
  360. private int
  361. dict_continue(register os_ptr op)
  362. {    es_ptr obj = esp - 2;
  363.     int index = (int)esp[-1].value.intval;
  364.     push(2);            /* make room for key and value */
  365.     if ( (index = dict_next(obj, index, op - 1)) >= 0 )    /* continue */
  366.        {    esp[-1].value.intval = index;
  367.         esp += 2;
  368.         *esp = obj[2];
  369.         return o_push_estack;
  370.        }
  371.     else                /* done */
  372.        {    pop(2);            /* undo push */
  373.         esp -= 4;        /* pop mark, object, index, proc */
  374.         return o_pop_estack;
  375.        }
  376. }
  377. /* Continuation operator for strings */
  378. private int
  379. string_continue(register os_ptr op)
  380. {    es_ptr obj = esp - 2;
  381.     if ( r_size(obj) )        /* continue */
  382.        {    r_dec_size(obj, 1);
  383.         push(1);
  384.         make_int(op, *obj->value.bytes);
  385.         obj->value.bytes++;
  386.         esp += 2;
  387.         *esp = obj[2];
  388.         return o_push_estack;
  389.        }
  390.     else                /* done */
  391.        {    esp -= 4;        /* pop mark, object, index, proc */
  392.         return o_pop_estack;
  393.        }
  394. }
  395. /* Continuation operator for packed arrays */
  396. private int
  397. packedarray_continue(register os_ptr op)
  398. {    es_ptr obj = esp - 2;
  399.     if ( r_size(obj) )        /* continue */
  400.        {    const ref_packed *packed = obj->value.packed;
  401.         r_dec_size(obj, 1);
  402.         push(1);
  403.         packed_get(packed, op);
  404.         obj->value.packed = packed_next(packed);
  405.         esp += 2;
  406.         *esp = obj[2];
  407.         return o_push_estack;
  408.        }
  409.     else                /* done */
  410.        {    esp -= 4;        /* pop mark, object, index, proc */
  411.         return o_pop_estack;
  412.        }
  413. }
  414. /* Vacuous cleanup procedure */
  415. private int
  416. forall_cleanup(os_ptr op)
  417. {    return 0;
  418. }
  419.  
  420. /* ------ Initialization procedure ------ */
  421.  
  422. BEGIN_OP_DEFS(zgeneric_op_defs) {
  423.     {"1copy", zcopy},
  424.     {"2forall", zforall},
  425.     {"2get", zget},
  426.     {"3getinterval", zgetinterval},
  427.     {"1length", zlength},
  428.     {"3put", zput},
  429.     {"3putinterval", zputinterval},
  430.         /* Internal operators */
  431.     {"0%array_continue", array_continue},
  432.     {"0%dict_continue", dict_continue},
  433.     {"0%packedarray_continue", packedarray_continue},
  434.     {"0%string_continue", string_continue},
  435. END_OP_DEFS(zgeneric_init) }
  436.  
  437. /* ------ Shared routines ------ */
  438.  
  439. /* Copy an interval from one operand to another. */
  440. /* This is used by both putinterval and string/array copy. */
  441. /* The destination is known to be an array or string, */
  442. /* and the starting index is known to be less than or equal to */
  443. /* its length; nothing else has been checked. */
  444. private int
  445. copy_interval(os_ptr prto, uint index, os_ptr prfrom, client_name_t cname)
  446. {    int fromtype = r_type(prfrom);
  447.     uint fromsize = r_size(prfrom);
  448.     if ( !(fromtype == r_type(prto) ||
  449.            ((fromtype == t_shortarray || fromtype == t_mixedarray) &&
  450.         r_type(prto) == t_array))
  451.        )
  452.         return_op_typecheck(prfrom);
  453.     check_read(*prfrom);
  454.     check_write(*prto);
  455.     if ( fromsize > r_size(prto) - index )
  456.         return_error(e_rangecheck);
  457.     switch ( fromtype )
  458.     {
  459.     case t_array:
  460.     {    /* We have to worry about aliasing, */
  461.         /* but refcpy_to_old takes care of it for us. */
  462.         return refcpy_to_old(prto, index, prfrom->value.refs,
  463.                      fromsize, cname);
  464.     }
  465.     case t_string:
  466.     {    /* We have to worry about aliasing. */
  467.         const byte *from = prfrom->value.bytes;
  468.         byte *to = prto->value.bytes + index;
  469.         uint i;
  470.         if ( from + fromsize <= to || to + fromsize <= from )
  471.             memcpy(to, from, fromsize);
  472.         else if ( to < from )
  473.             for ( i = fromsize; i != 0; i--, from++, to++ )
  474.                 *to = *from;
  475.         else
  476.             for ( i = fromsize, from += i, to += i; i != 0; i-- )
  477.                 *--to = *--from;
  478.     }    break;
  479.     case t_mixedarray:
  480.     case t_shortarray:
  481.     {    /* We don't have to worry about aliasing, because */
  482.         /* packed arrays are read-only and hence the destination */
  483.         /* can't be a packed array. */
  484.         int i;
  485.         const ref_packed *packed = prfrom->value.packed;
  486.         ref *pdest = prto->value.refs + index;
  487.         ref elt;
  488.         for ( i = 0; i < fromsize; i++, pdest++ )
  489.          { packed_get(packed, &elt);
  490.            ref_assign_old(prto, pdest, &elt, cname);
  491.            packed = packed_next(packed);
  492.          }
  493.     }    break;
  494.     }
  495.     return 0;
  496. }
  497.